test(cketh): build the live balance-scan harness on the shared fixtures - #11124

The previous commit's dedup removed live_scan.rs's local install_minter,
so "key_1" was only written once already; this replaces lib.rs's
remaining `.parse().unwrap()` literal with the named constant the
duplicate used to carry, avoiding an unnecessary fallible conversion.

Addresses PR #11124 review comments (Nit + Copilot):
#11124 (comment)
#11124 (comment)

The controller() doc wrongly blamed the anonymous-controller crash on
the controller identity. Re-tested per review: converging everything
else but keeping u128::MAX cycles (the shared mocked-fixture helper's
amount) reproduces the same crash with controller() left untouched,
confirming it is cycle-balance saturation (`AddAssign for Cycles`
saturates, so a canister already at u128::MAX cannot observe any
further addition, tripping the replica's cycle-accounting assertion on
its first live HTTPS outcall) — not the controller. controller() keeps
its own doc, now stating its real, sufficient justifications; the
cycles constraint is now documented at the add_cycles call sites.

Addresses PR #11124 review comment (Medium):
#11124 (comment)

Now that install_minter/install_evm_rpc are genuinely shared between
the two fixtures (previous commits), the enum backs both the EVM RPC
canister's install args and the minter's chain-state init args, not
just the EVM RPC side its old name implied.

Addresses PR #11124 review comment (Nit):
#11124 (comment)

…NUMBER_AT_INSTALL

Both Anvil arms already carried a one-clause reason; the Mocked arms
didn't, leaving a reader unable to tell why replaying canned mainnet
responses implies these two particular values without also reading the
enum's top-level doc.

Addresses PR #11124 review comment (Nit):
#11124 (comment)

…ses it

"every ckETH fixture creates" overstated it: the live harness creates
its 3 canisters itself, in a different order (ledger first, not
minter first) and under its own controller, then assembles this same
struct to feed the shared installers rather than creating it via
create_cketh_canisters.

Addresses PR #11124 review comment (Nit):
#11124 (comment)

…self

Deletes CkErc20LiveScanSetup and its new_live(), which still ran their
own canister creation, settings, cycles and install sequencing in
parallel to CkEthSetup::new — a second fixture in substance, not just
in name.

Adds a builder on CkEthSetup (CkEthSetup::builder()) with two knobs:
with_ethereum_backend (Mocked/Anvil, already shared via EthereumBackend)
and with_live_mode, which switches on every axis the live harness needs
and off by default: an NNS subnet in addition to the fiduciary one, a
fixed non-anonymous controller, u64::MAX cycles (headroom below the
saturating balance ceiling established in the prior fix), an
uninstalled placeholder ckETH ledger, and make_live before the minter
install. CkEthSetup::new/Default keep today's behaviour unchanged,
now delegating to the same builder in its default (mocked) mode.

The live-scan-specific behaviour (Holding, SupportedToken,
credit_deposits, await_scan, balance_scan_candidates, deposit_erc20,
register_deposit_address, depositor, ckERC20 activation and token
registration) now hangs off a thin LiveBalanceScanSetup that wraps
CkEthSetup plus the anvil node, rather than reimplementing any of it.

Built on CkEthSetup rather than CkErc20Setup: the balance scan needs
only the minter and EVM RPC canister, and CkErc20Setup would drag in a
real ledger-suite-orchestrator and spawned per-token ledgers for no
benefit here.

deposit_from_cex.rs updated to construct LiveBalanceScanSetup instead
of the deleted CkErc20LiveScanSetup.

…ence

The prior split kept the same duplication under a new name: two
sibling functions each spelling out the full canister-creation/install
sequence. Collapses them into a single CkEthSetupBuilder::build with a
small number of conditionals instead:

- One new_env(live) builds the PocketIC instance for both modes:
  fiduciary subnet always, NNS subnet added and made live in live mode.
  make_live now runs before any canister of this fixture exists (no
  install has scheduled a timer yet), rather than between the EVM RPC
  and minter installs — verified against the live suite, not assumed.
- create_cketh_canisters takes the single controller: Option<Principal>
  CkEthCanisters already carried, via a create_canister(env, controller)
  helper; no separate CanisterSettings axis on the builder.
- Cycle amount is unified to u128::from(u64::MAX) for both modes,
  removing the last hardcoded fork; verified no test asserts a cycle
  balance by running the full suite.
- Canister creation order (minter first) is untouched, so it is shared
  by construction rather than by convention.

The one axis that stayed conditional: installing the real ckETH ledger
for the live harness too. Tried it; it fails outright, because the
anvil-backed deposit_from_cex Bazel target does not declare the ledger
canister Wasm as a data dependency, so load_wasm's cargo-metadata
fallback has no access to the ledger crate's directory in that
sandbox. Kept as `if !self.live { install_ledger(..) }`, documented at
the call site with the failure mode that was actually observed.

CkEthSetup::new/Default are unaffected in creation order, MINTER_ADDRESS
derivation and the cold-start property (new_env(false) never calls
make_live).

The Ethereum backend decides how the instance is built — a live one for
anvil, a plain one for the mocked responses — yet the builder still accepted
a caller-supplied instance, with nothing checking that it matched. Every
caller passed the very instance the mocked backend would have built anyway,
so the parameter only offered a way to get it wrong.

Build the instance from the backend alone and drop the whole chain that
threaded one in: with_env, CkEthSetup::new, new_pocket_ic, and CkErc20Setup's
env arguments. CkErc20Setup now takes the shared instance from the ckETH
fixture it builds first, which is the sharing it actually needed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

…ery backend

The live harness owned its canisters with a dedicated non-anonymous principal
and skipped the ckETH ledger install, so which canisters existed and who
controlled them depended on the Ethereum backend — a chain the fixture talks
to, which has no bearing on either.

Neither difference was load-bearing. The anonymous principal already controls
every canister PocketIC creates by default, which is what makes the minter's
controller-only logs readable as the anonymous caller, and the minter's
orchestrator check is a plain caller comparison that an anonymous stand-in
id satisfies. The skipped ledger install was down to the ledger Wasm missing
from the anvil-backed test target's Bazel data, so declare it there.

Canister creation and installation now match master exactly, for both
backends, and the backend decides only what it actually determines: how the
PocketIC instance is built and what the minter and EVM RPC canister are
initialised with.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

The harness activated the ckERC20 feature and registered ckUSDC/ckUSDT
itself, standing in for an orchestrator: it pointed the minter's
orchestrator id at a principal it could call as, and invented a placeholder
ledger id per token that nothing ever calls. That was only to avoid the
ledger suites the balance scan does not read — but testing the deposit flow
will need them.

Wrap the anvil-backed ckETH fixture in CkErc20Setup instead, whose real
orchestrator registers the same two tokens at the same mainnet addresses the
scan reads, and drop both stand-ins.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Integrates the pocket_ic_builder inlining pushed to the branch. That change
is already present in this branch's tree, so the merged tree is unchanged;
the conflicting hunks were EnvMode and new_pocket_ic, both removed here.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

After with_env was removed upstream and with_live_mode went away in
7a5682b, CkEthSetupBuilder was a one-field struct with a single
setter and two call sites: a constructor spelled in three calls
(builder(), with_ethereum_backend(..), build()).

CkEthSetup::new(env: Arc<PocketIc>) disappeared when the fixture took
over building its own PocketIC instance, freeing the name (confirmed
via grep: no remaining caller anywhere in rs/). CkEthSetup::new(backend:
EthereumBackend) now does what CkEthSetupBuilder::build did; Default
calls it with EthereumBackend::Mocked, and live_scan calls it directly
with EthereumBackend::Anvil(..).

Privacy is unchanged: new is private, and live_scan reaches it exactly
as it reached builder before, being a descendant module of the crate
root — no pub/pub(crate) added, confirmed by cargo check.

EthereumBackend itself is untouched: it still drives install_args,
ethereum_block_height and last_scraped_block_number, which are real
Mocked-vs-Anvil differences.

Verification: rustfmt, cargo check --all-targets --all-features,
clippy (pinned flags, --all-targets) all clean. bazel test, all
--nocache_test_results: cketh_test, ckerc20_test, test_utils:lib_tests
all pass; deposit_from_cex passes 5/5 under
--runs_per_test=5 --local_test_jobs=5.

Resolves the conflicts #10946 (move funded deposit addresses to a
balance-sweep queue) created with this branch's rework of the live
balance-scan harness. Both sides touched live_scan.rs.

Conflicts and how they were resolved:

- live_scan.rs imports: took master's DepositStatus, dropped
  AddCkErc20Token. This branch no longer registers supported tokens by
  hand -- CkErc20Setup does it -- so the type is unused here.

- live_scan.rs balance_scan_candidates()/candidates_in_log(): took
  master's deletion. #10946 surfaces a funded address through
  DepositStatus::AwaitingSweep instead of the [balance_scan] log line
  those helpers parsed, and the merged deposit_from_cex.rs asserts on
  that status rather than on a candidate count, so nothing calls them.

- tests/ckerc20.rs imports: kept only BTreeSet. master's new_pocket_ic
  and Arc were needed for
  CkErc20Setup::new_without_ckerc20_active(Arc::new(new_pocket_ic())),
  and on this branch the fixture builds its own PocketIC instance, so
  both call sites take no argument and new_pocket_ic no longer exists.

await_scan came through the merge with master's DepositStatus-based
body, which is what the merged deposit_from_cex.rs expects.

- CkEthSetup::new: "anonymous controller" referred to the installed
  canisters, not the PocketIC instance; reworded.
- CkEthCanisters: "installed ... identically for every backend" was
  wrong — install_minter/install_evm_rpc take &backend and produce
  different init args (override provider, block tag, last scraped
  block). What's identical is the canister set, creation order and
  controller.
- CANISTER_CYCLES: the rationale read live-specific, but the constant
  funds every fixture, mocked included. States that funding every
  fixture the same amount is deliberate, rather than scoping the lower
  amount back to EthereumBackend::Anvil.
- EthereumBackend::Anvil: fixed two errors — the Arc clone held here
  does not outlive construction (CkEthSetup::new takes backend by
  value and drops it once install args are computed; the harness'
  own, separate Arc clone is what keeps anvil running), and "created
  and installed exactly as for Mocked" had the same init-args problem
  as CkEthCanisters' doc.
- ckerc20.rs: "its Ethereum backend decides how [the instance is
  built]" no longer holds after 7a5682b made new_env() unconditional;
  the backend only picks init args now.
- live_scan.rs module doc: states the mechanism that makes "build
  first, go live last" safe — PocketIC's auto-progress dispatch
  (ProcessCanisterHttpInternal) re-scans every canister's current
  canister_http_request_contexts() each round and dispatches whichever
  it hasn't already sent to the adapter, so outcalls issued by the
  minter's startup timers during the non-live construction phase are
  picked up for real once auto_progress() starts, not dropped.
  Confirmed by reading rs/pocket_ic_server/src/pocket_ic.rs:3792-3812.

Addresses PR #11124 review comments:
#11124 (comment)
#11124 (comment)
#11124 (comment)
#11124 (comment)
#11124 (comment)
#11124 (comment)

SupportedToken::ALL and credit_deposits hardcoded ckUSDC/ckUSDT, while
add_supported_erc20_tokens() registers whatever
ic_ledger_suite_orchestrator_test_utils::supported_erc20_tokens()
returns. The two could silently disagree: a third token added upstream
would get no code on anvil, and per credit_deposits' own comment, a
token without code reverts the whole scan even for holdings that don't
involve it — surfacing as a 180s hang with a message pointing nowhere.

Deletes SupportedToken and passes the orchestrator's own Erc20Token
(AddErc20Arg) through instead, so the set that gets code on anvil IS
the registered set, by construction rather than convention:

- Holding<'a> borrows &'a Erc20Token rather than owning a SupportedToken
  copy — the lifetime stayed simple enough at every call site that a
  cloned Erc20Token was never needed.
- credit_deposits takes each holding's address off its own token and
  iterates self.supported_erc20_tokens() instead of SupportedToken::ALL.
- deposit_erc20/register_deposit_address/await_scan (widened by the
  master merge to take a token) take &Erc20Token too.
- A new supported_erc20_tokens() accessor exposes the registered list,
  so deposit_from_cex.rs destructures
  `let [usdc, usdt] = setup.supported_erc20_tokens() else { panic!(..) }`
  — the let-else doubling as the loud arity check.
- USDT_ERC20_CONTRACT_ADDRESS is gone; it only existed to feed the enum.

Checked the EIP-55 case rather than assuming it: the minter's reported
erc20_contract_address is compared against token.contract.address
directly (no re-normalizing through Address::to_string()), and the
live suite's 10/10 contention passes confirm the two already agree.

Addresses PR #11124 review comment:
#11124 (comment)